home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / escalant / escala21.lha / escalante2.1 / src / vgm / VGraphElement.h < prev    next >
C/C++ Source or Header  |  1993-07-15  |  22KB  |  1,001 lines
  1. //
  2. //    Copyright (C) 1993  Jeff McWhirter
  3. //
  4.  
  5. #ifndef VGRAPHELEMENT_H  
  6. #define VGRAPHELEMENT_H
  7. #include    "EscalanteGlobal.h"
  8.  
  9. #include    "PVGraphElement.h"
  10. #include    "CommonGfx.h"
  11. #include    "Point.h"
  12. #include    "Rectangle.h"
  13.  
  14.  
  15. //
  16. //Various global flags
  17. //
  18.  
  19.  
  20.  
  21.  
  22. extern bool gWriteOutGfx;     //When doing IO do we write out theimage
  23. extern bool gMoveHint;        //Is  the event eAEventMoveByHint active
  24. extern bool gScaleHint;        //Is  the event eAEventScaleByHint active
  25. extern bool gLCHint;         //Are hint location constraints active
  26.  
  27. extern int  gMaxEndPtHops;    //How many hops do we go when looking for an endpoint
  28.  
  29. extern bool gDoLC;        //Are all location constraints active
  30.  
  31. extern bool gPropagateMove;    //Do we propagate position changes
  32.  
  33. extern bool gCopySGelt;        //Do we make a copy of the sgelt when copying the vgelt
  34.  
  35. extern bool gKeepSGelt;        //If a vgelt is copied and the selt wasn't 
  36.                 //do we  keep the old sgelt
  37.  
  38.  
  39.  
  40.  
  41.  
  42. class GfxSet;
  43. class Gfx;
  44. class Rectangle;
  45. class Line;
  46. class TextGfx;
  47. class VEntity;
  48. class VRelation;
  49. class PVRelation;
  50.  
  51.  
  52.  
  53. class VGraphElement;
  54. class PointArray;
  55. class ObjectGrid;
  56. class TimerObject;
  57.  
  58.  
  59.  
  60. #ifdef USE_STRUCTURAL 
  61. class SRelation;
  62. class SGraphElement;
  63. extern VGraphElement * (*gFindPrototype)(SGraphElement *sg, VGraphElement * original, VGraphElement * graph);
  64.  
  65. #endif
  66.  
  67.  
  68. typedef bool (*ElementOkFunc)(VGraphElement*);
  69. extern ElementOkFunc gElementOkFunc;
  70. extern void * gElementOkFuncData;
  71.  
  72.  
  73.  
  74. //
  75. //These procedures are used as propagating functions  to turn on(off) head(tail)
  76. //of incident relaitons
  77. //
  78. bool HeadVisOff (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  79. bool HeadVisOn (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  80. bool TailVisOff (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  81. bool TailVisOn (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  82.  
  83.  
  84. //
  85. //Same as above but use the bit in the relation, eShownFlag, to set the visibility
  86. // 
  87. bool  TurnOffHead(VGraphElement*root, VRelation* rel, VGraphElement* target);
  88. bool  TurnOnHead(VGraphElement*root, VRelation* rel, VGraphElement* target);
  89. bool  TurnOffTail(VGraphElement*root, VRelation* rel, VGraphElement* target);
  90. bool  TurnOnTail(VGraphElement*root, VRelation* rel, VGraphElement* target);
  91.  
  92.  
  93.  
  94. //
  95. //These procedures are used as propagating functions  to turn on(off) the gfx
  96. //of  the head(tail)  of incident relations
  97. //
  98.  
  99. bool HeadGfxOff (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  100. bool HeadGfxOn (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  101. bool TailGfxOff (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  102. bool TailGfxOn (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  103.  
  104.  
  105. //
  106. //Propagate the scaling of elements
  107. //
  108. bool Scaler (VGraphElement*, VRelation*, VGraphElement*,void * ,int , bool & );
  109.  
  110.  
  111.  
  112.  
  113. enum AddJointType{
  114.     eJointFirst,
  115.     eJointLast,
  116.     eJointClosest};
  117.  
  118.  
  119. enum VGEFlags{
  120.     eVGEVisible =         BIT(0),    
  121.     eVGEBaseVisible =     BIT(1),    
  122.     eVGEBuffering =     BIT(2),
  123.     eVGEInNewElement =     BIT(3),
  124.     eVGEDrawOthers =     BIT(4),
  125.     eVGEInSomething =     BIT(5),
  126.     eVGEGoingToUpdate =    BIT(6),    
  127.     eVGEIbboxReference =     BIT(7),    
  128.     eVGEShowInPalette =     BIT(8),    
  129.     eVGEAcceptMapping =     BIT(9),    
  130.     eVGEInGetEndPt =    BIT(10),
  131.     eVGEGfxChanged =    BIT(11),
  132.     eRelativeJoints =     BIT(12),
  133.     eNeedJoints =         BIT(13),
  134.     eWriteGfx =         BIT(14),
  135.     eAcceptPosChange =     BIT(15),
  136.     eVGEMapWidth    =     BIT(16),    
  137.     eVGEMapHeight    =     BIT(17),     
  138.     eVGEMapArea    =     BIT(18),    
  139.     eVGEMapNWX    =     BIT(19),    
  140.     eVGEMapSEX    =     BIT(20),    
  141.     eVGEMapNWY    =     BIT(21),    
  142.     eVGEMapSEY    =     BIT(22),    
  143.     eVGELast = 22,
  144.     eVGraphElementLast = ePVGraphElementLast,
  145. };
  146.  
  147.  
  148.  
  149.  
  150. VGraphElement * CloneElt(VGraphElement * oldvelt,
  151.         VGraphElement * vg,
  152.         Point dp = gPoint0);
  153.  
  154.  
  155.  
  156.  
  157. #define BEGIN_VGE_GUARD(the_flag) if(!TestVGEFlag(the_flag)){ SetVGEFlag(the_flag,TRUE);
  158. #define END_VGE_GUARD(the_flag)  SetVGEFlag(the_flag,FALSE);}
  159.  
  160.  
  161. #ifdef USE_STRUCTURAL
  162. #define ALLVGELTS(velt,func,type) \
  163.     SGraphElement * sg =velt-> GetSGelt();\
  164.     if(!sg)return;\
  165.     if(!sg->vgelts)return;\
  166.     Iter next(sg->vgelts);\
  167.     register type * vwxy;\
  168.     while(vwxy = (type *) next())\
  169.            if(vwxy->IsKindOf(type))\
  170.                vwxy->func
  171.  
  172.  
  173. #define ALLVGELTSPOS(velt,func,type) \
  174.     SGraphElement * sg =velt-> GetSGelt();\
  175.     if(!sg)return;\
  176.     if(!sg->vgelts)return;\
  177.     Iter next(sg->vgelts);\
  178.     register type * vwxy;\
  179.     while(vwxy = (type *) next())\
  180.            if(vwxy->IsKindOf(type))\
  181.                 if(!(vwxy != velt && !vwxy->AcceptPosChange())) \
  182.                          vwxy->func
  183.  
  184. #endif
  185.  
  186.  
  187. #ifndef USE_STRUCTURAL
  188. #define ALLVGELTS(velt,func,type) \
  189. velt->func
  190.  
  191.  
  192. #define ALLVGELTSPOS(velt,func,type) \
  193. velt->func
  194. #endif
  195.  
  196.  
  197. #define BEGINLOOP(elt,ename,rname,dir) {\
  198.         if(elt->GetRelations(dir)){\
  199.     Iter eltloopiter(elt->GetRelations(dir));\
  200.     while(rname=(VRelation*)eltloopiter()) {\
  201.         ename = (VGraphElement*)rname->GetOtherElement(elt); 
  202.  
  203. #define ENDLOOP }}}
  204.  
  205.  
  206.  
  207.  
  208. #define VINOUT(element,rname,rtype,ename,etype) {\
  209.         Iter eltloopiter(element->GetRelations(eIn));\
  210.              for(int iii = 0;iii <2;iii++){\
  211.         if(iii == 1) eltloopiter.Reset(element->GetRelations(eOut));\
  212.             while(rname=(rtype*)eltloopiter()) \
  213.                 if(rname->IsKindOf(rtype) && (ename = (etype*)rname->GetOtherElement((element))) && (ename->IsKindOf(etype))) {
  214.  
  215.  
  216. #define ENDVINOUT }}}
  217.  
  218. #define VBEGINRLOOP(element,dir,rname,rtype,ename,etype) {\
  219.         if((element)->GetRelations(dir)){\
  220.           Iter eltloopiter((element)->GetRelations(dir));\
  221.           while(rname=(rtype*)eltloopiter()) \
  222.           if(rname->IsKindOf(rtype) && (ename = (etype*)rname->GetOtherElement((element))) && (ename->IsKindOf(etype))) {
  223.  
  224.  
  225. #define VENDRLOOP }}}
  226.  
  227.  
  228. #define VOUT(element,rname,rtype,ename,etype) VBEGINRLOOP(element,eOut,rname,rtype,ename,etype)
  229. #define ENDVOUT VENDRLOOP
  230.  
  231. #define VOUTTHIS(rname,rtype,ename,etype) VBEGINRLOOP(this,eOut,rname,rtype,ename,etype)
  232. #define ENDVOUTTHIS VENDRLOOP
  233.  
  234. #define VIN(element,rname,rtype,ename,etype) VBEGINRLOOP(element,eIn,rname,rtype,ename,etype)
  235. #define ENDVIN VENDRLOOP
  236.  
  237. #define VINTHIS(rname,rtype,ename,etype) VBEGINRLOOP(this,eIn,rname,rtype,ename,etype)
  238. #define ENDVINTHIS VENDRLOOP
  239.  
  240.  
  241. #define VITERELTS(element,ename,rname) VBEGINRLOOP(element,eOut,rname,VMemberOf,ename,VGraphElement)
  242. #define VENDITER VENDRLOOP
  243.  
  244.  
  245.  
  246.  
  247.  
  248. #define VGraphElement_BASE PVGraphElement
  249. class VGraphElement : public VGraphElement_BASE {
  250. public:
  251. long int VGEFlag; 
  252.  
  253. //
  254. //p1 and p2 define the position and size of this element.
  255. //joints are a list of other points
  256. //The Gfx objects associated with this element, (contianed in theimage)
  257. //get their position and sioze from these points
  258. //
  259. Point p1,p2;
  260. PointArray  * joints;
  261.  
  262. GfxSet * theimage;
  263.  
  264.  
  265. //
  266. //What views does this element draw itself and others in
  267. //
  268. ObjList * views;
  269.  
  270. //
  271. //Corresponding SGraphElement
  272. //
  273. #ifdef USE_STRUCTURAL
  274. SGraphElement * sgelt;
  275. void        RemoveSGelt();
  276. void        SetSGelt(SGraphElement * sg);
  277. SGraphElement*    GetSGelt(){return sgelt;}
  278. virtual void    InitSVAMap(){}
  279. VGraphElement*    FindVGelt(SGraphElement * sg);
  280. bool        OkToAddElement(SGraphElement * sg){return MS_OkToAddElement(sg);}
  281. virtual    bool    MS_OkToAddElement(SGraphElement * ){return TRUE;}
  282.  
  283.  
  284.  
  285. //
  286. //These methods are used when looking for a prototype element.
  287. //They are called when  the SGraphElement this element is
  288. //associated with has added an element. The sgelt calls 
  289. //VGraphElement::NewElement(SGraphElement*sg). This element 
  290. //calls FindPrototype to see if there is a element in the protos
  291. //list that has a sgelt of the same type of the sg argument to
  292. //NewElement. If FindPrototype returns 0 then MS_FindPrototype 
  293. //is called. If that returns 0 then if the function ptr, gFindPrototype,
  294. //is  non-null  than that is called. If that returns 0 then no element 
  295. //is added.
  296. //
  297.  
  298. VGraphElement*    FindPrototype(Class * sclass,Class * vclass =0);
  299. VGraphElement*    FindPrototype(SGraphElement * s = 0,VGraphElement * v = 0);
  300. virtual VGraphElement* MS_FindPrototype(SGraphElement *sg, VGraphElement * original){
  301. return 0;
  302. }
  303.  
  304.  
  305. //
  306. //This is called by the sgelt when the sgelt has added an element
  307. //
  308.  
  309. VGraphElement*    NewElement(SGraphElement * s,
  310.         SRelation * sr = 0,
  311.         VGraphElement * original=0);
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318. VGraphElement*    NewElement(VGraphElement * velt,SGraphElement * selt){
  319.             return NewElement(velt,0,selt,0,velt);
  320.         }
  321.  
  322.  
  323. //
  324. //This is called when a new element is added directly to this element
  325. // 
  326.  
  327. VGraphElement*    NewElement(VGraphElement * velt,VRelation * vrel=0,
  328. SGraphElement * selt=0,
  329. SRelation * srel=0,VGraphElement * original=0
  330. );
  331.  
  332. #endif
  333.  
  334.  
  335.  
  336. #ifndef USE_STRUCTURAL
  337. VGraphElement*    NewElement(VGraphElement * velt,VRelation * vrel=0){AddElement(velt,vrel)}
  338. #endif
  339.  
  340.  
  341. //
  342. //This is called when a set of elements are added directly to this element
  343. //
  344. void        NewElement(class Set*);
  345.  
  346.  
  347.  
  348. //
  349. //If this element is in a prototype list can it be used as a prototype
  350. //when we get a NewElement from a connected SGraphElement. 
  351. //
  352.  
  353. bool    AcceptMapping(){return TestVGEFlag(eVGEAcceptMapping);}
  354. void     AcceptMapping(bool b){SetVGEFlag(eVGEAcceptMapping,b);}
  355.  
  356.  
  357.  
  358. //
  359. //Bounding box of any elements  this element has an eIBBoxReference 
  360. //dependency with 
  361. //
  362. #ifdef USE_IBBOX_REF
  363. Rectangle ibbox;
  364. #endif
  365.  
  366. MetaDef(VGraphElement);
  367. VGraphElement();
  368. ~VGraphElement();
  369.  
  370.  
  371.  
  372. void Init();
  373. void InitClone();
  374. void InitAfterReading();
  375. void InitAfterClone();
  376.  
  377.  
  378.  
  379. virtual ObjectGrid* GetGrid(){return 0;}
  380. virtual    TimerObject* GetTimer(){return 0;}
  381. virtual void Tick(){}
  382.  
  383. void ResolvePtrNeeds();
  384. void *DoEvent(Events event, PVGraphElement * elt =0, void * data=0);
  385.  
  386. //
  387. //This returns a new relation of type VMemberOf. This is called when
  388. //an element is added to this element
  389. //
  390. PVRelation * GetDefaultMemberOf();
  391.  
  392.  
  393. void AddGroupRelation(PVRelation * );
  394.  
  395.  
  396. //
  397. //Access for the two pointsP1 and P2
  398. //
  399. void SetP1(Point p){p1 = p;SignalSizeChange();}
  400. void SetP2(Point p){p2 = p; SignalSizeChange();}
  401. void SetP1P2(Point pp1,Point pp2){p1 = pp1;p2 = pp2; SignalSizeChange();}
  402.  
  403.  
  404.  
  405. //
  406. //This method returns  the minimum extent of this element 
  407. //
  408. virtual Point GetMinExtent(){return AsRect().extent;}
  409.  
  410.  
  411. //
  412. //When adding this element do we want to add a bunch of joints
  413. //
  414.  
  415. bool     NeedJoints(){return TestVGEFlag(eNeedJoints);}
  416. void     NeedJoints(bool b){SetVGEFlag(eNeedJoints,b);}
  417.  
  418. //
  419. //When called by All... do we accept such a call
  420. //
  421. bool     AcceptPosChange(){return TestVGEFlag(eAcceptPosChange);}
  422. void     AcceptPosChange(bool b){SetVGEFlag(eAcceptPosChange,b);}
  423.  
  424.  
  425. //
  426. //When writing out this object is theimage also written out
  427. //Normally it isn't. IO seems to be quicker that way.
  428. //Of course you can't   save any state that has changes in the Gfx's
  429. //
  430. bool     WriteGfx(){return TestVGEFlag(eWriteGfx);}
  431. void     WriteGfx(bool b){SetVGEFlag(eWriteGfx,b);}
  432.  
  433. //
  434. //Are the joints that I have relative to the point p1
  435. //
  436. bool     RelJoints(){return TestVGEFlag(eRelativeJoints);}
  437. void     RelJoints(bool b){SetVGEFlag(eRelativeJoints,b);}
  438.  
  439.  
  440. //
  441. //Mutliple access to the joints
  442. //
  443. void    AllMoveJoint(Point p,int ix); 
  444. void    AllMoveJointBy(Point p,int ix); 
  445. void    AllAddJointAt(Point p, int ix);
  446. void    AllAddJointFirst(Point p);
  447. void    AllAddJointLast(Point p);
  448. void    AllAddJoint (Point  p);
  449. void    AllAddJoint (Point  p,AddJointType t);
  450.  
  451.  
  452. //
  453. //Catch the setting dead. If we get undead then update image and redraw
  454. // 
  455. void    SetDead(bool f);
  456. void    AllSetDead(bool b);
  457.  
  458.  
  459.  
  460.  
  461.  
  462. //
  463. //A bunch of joint things
  464. //
  465. Point TransPoint(Point p){return p + (RelJoints()?p1:gPoint0);}
  466.  
  467.  
  468.  
  469. void    MoveJoint(Point p,int ix);
  470. void    MoveJointBy(Point p,int ix);
  471. void    AddJoint (Point  p);
  472. void    AddJoint (Point  p,AddJointType t);
  473. int    IndexOfLocPt(LocPt lp);
  474. void    RemoveJoint(int ix);
  475. void    RemoveAllJoints();
  476. void    RemoveClosestJoint (Point  p);
  477. Point    GetPointAlongLine(float perc);
  478. void    CheckJoints();
  479. void    AddJointAt(Point p, int ix);
  480. void    AddJointFirst(Point p);
  481. void    AddJointLast(Point p);
  482. Point    MiddlePoint();
  483. int    NumberOfJoints();
  484. Point    GetFirstJoint();
  485. Point    GetLastJoint();
  486. int    GetIndexAt(Point p);
  487. Point    GetJointAt(int at);
  488. Point    GetP1Less1();
  489. Point    GetP2Less1();
  490.  
  491. //
  492. //Move a point on me defined by LP (e.g. cNM, cCenter)
  493. //
  494. void    Reshape(Point, LocPt,bool both = FALSE);
  495. void    ReshapeBy(Point, LocPt,bool both = FALSE);
  496.  
  497.  
  498. virtual void         MoveBy(Point);
  499. void            MoveTo(Point);
  500.  
  501. //
  502. //return the Rectangle formed by p1 and p2
  503. //
  504. Rectangle    AsRect();
  505.  
  506. //
  507. //return the Line formed by p1 and p2
  508. //
  509. Line    AsLine();
  510.  
  511.  
  512.  
  513. Point    GetOrigin(){return AsRect().origin;}
  514. void    SetOrigin(Point p, bool notify = TRUE);
  515. void    SetExtent(Point p, bool notify = TRUE);
  516.  
  517.  
  518. void    AllShrink();
  519. void    AllShrinkX();
  520. void    AllShrinkY();
  521.  
  522.  
  523. void    Shrink();
  524. void    ShrinkX();
  525. void    ShrinkY();
  526.  
  527.  
  528.  
  529. double    Angle();
  530. void    RotateByRadian(double theta = 0.0);
  531. void    RotateByDegree(double degree = 0.0);
  532. void    RotateTo(Point p);
  533.  
  534.  
  535.  
  536. void    Scale(float , float ,Point);
  537. void    Scale(float sx , float sy ){Scale(sx,sy,AsRect().Center());}
  538. void    Scale(float f1){Scale(f1,f1);}
  539.  
  540.  
  541.  
  542.  
  543. void*    GetAttribute(int aid,DataType & type);
  544. void    ChangeAttribute(int aid, void * data, DataType type);
  545.  
  546. AttrMap*    MapAttribute(int external,
  547.         int internal,
  548.         Object * fromobj,
  549.         AttrFilter * af=0);
  550.  
  551.  
  552.  
  553.  
  554.  
  555. //
  556. //VGraphElement has its own flags (we were running out
  557. //of the ones the Object class provides
  558. //
  559. bool     TestVGEFlag(int f){return TestMask(VGEFlag,f);}
  560. void     SetVGEFlag(int f,bool b){SetMask(VGEFlag,f,b);}
  561.  
  562.  
  563.  
  564. //
  565. //Gets called by the View when this element is shown in a palette
  566. //Returns the name of the bitmap file to be displayed
  567. //
  568.  
  569. virtual char* GetIconName(){return "Node.im";}
  570.  
  571.  
  572. //
  573. //If this element is in a prototype list iun the view do
  574. //we show it in the palette?
  575. //
  576. bool     ShowInPalette(){return TestVGEFlag(eVGEShowInPalette);}
  577. void     ShowInPalette(bool b){SetVGEFlag(eVGEShowInPalette,b);}
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584. //
  585. //Flag to see when a Gfx has changed. We use this when we're
  586. //buffering changes.
  587. //
  588. bool     GfxChanged(){return TestVGEFlag(eVGEGfxChanged);}
  589. void     GfxChanged(bool b){SetVGEFlag(eVGEGfxChanged,b);}
  590.  
  591.  
  592.  
  593. //
  594. //These are virtual methods defined in PVGraphElement
  595. //We catch them here to see if the new relation contains
  596. //any event dependencies or location constriants that affect us
  597. //  
  598. void     AddInRelation(PVRelation *);
  599. void     AddOutRelation(PVRelation *);
  600. void      NewTail(PVRelation * r, PVGraphElement * elt=0,PVGraphElement * oldtl=0);
  601. void     NewHead(PVRelation * r, PVGraphElement * elt=0,PVGraphElement * oldhd=0);
  602. void     RemoveOutRelation(PVRelation *r);
  603. void    RemoveInRelation(PVRelation *r);
  604.  
  605.  
  606. //
  607. //These methods let you turn on(off) the visibility of  elements that this
  608. //element  draws
  609. //
  610. void    SetEltVisibility(class Class * c,bool state,bool protosToo = TRUE, Object * view =0);
  611. void    SetEltVisibility(RDir dir,
  612.         bool state = FALSE,
  613.         class Class * relClass = 0,
  614.         class Class * eltClass = 0,
  615.          Object * view =0
  616.           );
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623. //
  624. //This method lets  you get the bounding box of the elements this element draws
  625. //
  626. void    GetElementBBox(Rectangle &r,Object * view =0);
  627. void    GetElementBBox2(Rectangle &r,Object * view =0);
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634. //
  635. //All of these methods let you find other elements. Either ones
  636. //contained by soem rectangle or ones closest to a point. 
  637. //If you look in EscalanteView you can see how these are called 
  638. //
  639.  
  640. void    FindElements2(Rectangle r,
  641.         Set & s,
  642.         class Class * c,
  643.         Object * v);
  644.  
  645. bool    FindElements(Rectangle r,
  646.         Set & s,
  647.         class Class * c = 0,
  648.         Object * view =0);
  649.  
  650. void    FindContainedElements2(Rectangle r,
  651.         Set & s,
  652.         class Class * c,
  653.         Object * v,
  654.         bool UseGfxIbbox  = TRUE);
  655.  
  656. bool    FindContainedElements(Rectangle r,
  657.         Set & s,
  658.         class Class * c = 0,
  659.         Object * view =0,
  660.         bool UseGfxIbbox  = TRUE);
  661.  
  662. bool    FindEntities( Rectangle r,Set & s,class Class * c = 0);
  663. bool    FindRelations( Rectangle r, Set & s,class Class * c = 0);
  664.  
  665.  
  666. void     FindClosest2(Point p,
  667.         VGraphElement * & elt,
  668.         Gfx * & gfx,
  669.         class Class * eltclass,
  670.         int gravity,
  671.         Object * view,
  672.         bool input = FALSE,
  673.         int *distance=0);    
  674.  
  675.  
  676. void    FindClosest(Point p,
  677.         VGraphElement * & elt,
  678.         Gfx * & gfx,
  679.         class Class * eltclass=0,
  680.         int gravity = MAXINT,
  681.         Object * view = 0,
  682.         bool input = FALSE,
  683.         int *distance  = 0);    
  684.  
  685.  
  686. VGraphElement*    FindClosestElement(Point p,
  687.         class Class * c,
  688.         int gravity = MAXINT,
  689.         Object * view = 0);
  690.  
  691. VEntity*    FindClosestEntity(Point p,
  692.         class Class * c = 0,
  693.         int gravity = MAXINT,
  694.         Object * view = 0);
  695.  
  696. VRelation*    FindClosestRelation(Point p,
  697.         class Class * c = 0,
  698.         int gravity = MAXINT,
  699.         Object * view = 0);
  700.  
  701. Gfx*        FindClosestGfx(Point p,
  702.         class Class * eltclass = 0,
  703.         int gravity = MAXINT,
  704.         Object * view = 0);
  705.  
  706. Gfx*        FindClosestInputGfx(Point p,
  707.         class Class * eltclass = 0,
  708.         int gravity = MAXINT,
  709.         Object * view = 0);
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716. //
  717. //This finds elements that draw this element
  718. //
  719. VGraphElement*    FindDrawer();
  720. VGraphElement*    FindDrawer(class Class* c);
  721. void        FindDrawers(Set & l);
  722.  
  723. //
  724. //Move this element visually to the back(front).
  725. //In essence switch  the position of the relation that draws this element 
  726. //
  727. void    ToBack(){
  728.     VGraphElement * drawer = FindDrawer();
  729.     if(drawer) drawer->ToBack(this);
  730. }
  731.  
  732. void ToFront(){
  733.     VGraphElement * drawer = FindDrawer();
  734.     if(drawer) drawer->ToFront(this);
  735. }
  736.  
  737. //
  738. //Move some element to the back(front)
  739. //
  740. void ToFront(VGraphElement * vg);
  741. void ToBack(VGraphElement * vg);
  742.  
  743.  
  744.  
  745.  
  746. //
  747. //If we have stopped adding this element then
  748. //act like it has moved so that it checks its image and
  749. //tells other connected elements it has moved 
  750. //(a performance hack)
  751. //
  752. void SetAdding(bool b){
  753.     VGraphElement_BASE::SetAdding(b);
  754.     if(!b)Moved();
  755. }
  756.  
  757.  
  758.  
  759. //
  760. //Tell others this element has moved
  761. //
  762.  
  763.  
  764.  
  765.  
  766. void    Moved(Events not= eEventNull,bool force = FALSE);
  767. void    ExternalMove();
  768. void    SendPositionChange(bool force = TRUE);
  769.  
  770.  
  771. //
  772. //When this element has moved call this. A hook.
  773. //
  774. virtual void MS_Moved(){}
  775.  
  776.  
  777.  
  778. void    DoObserve(int , int , void * , Object *);
  779.  
  780.  
  781. //
  782. //Flags to squelch any broadcasts of position changes
  783. //
  784. bool    GoingToUpdate(){return TestVGEFlag(eVGEGoingToUpdate);}
  785. void    GoingToUpdate(bool f){SetVGEFlag(eVGEGoingToUpdate,f);}
  786.  
  787. //
  788. //A bunch of things for Location Constraints.
  789. //
  790. #ifdef USELC
  791. ObjList * outlcs;
  792. ObjList * inlcs;
  793.  
  794. void    AddInLC(Object*);
  795. void    RemoveInLC(Object*);
  796. void    AddOutLC(Object*);
  797. void    RemoveOutLC(Object*);
  798.  
  799. bool     FindLocDepSize(Point &np1, Point & np2);
  800. void    LCChanged();
  801. #endif USELC
  802.  
  803.  
  804.  
  805. //
  806. //Buffer position and image changes
  807. //
  808. void    SetBuffering(bool b);
  809. bool    Buffering(){return TestVGEFlag(eVGEBuffering);} 
  810.  
  811.  
  812. //
  813. //Access for various bounding boxes of this element
  814. //
  815. Rectangle     GetIBBox();
  816. Rectangle     GetGfxIBBox();
  817. bool         ResetIBBox(bool force = FALSE);
  818.  
  819.  
  820.  
  821. void    SetGfxVisibility(int id,bool state,
  822.          bool prop = FALSE,
  823.         bool protosToo = FALSE,
  824.         Object * view = 0);
  825.  
  826. void    SetGfxVisibility2(int id,
  827.         bool state,
  828.          bool prop = FALSE,
  829.         bool protosToo = FALSE,
  830.         Object * view = 0);
  831.  
  832. void    SetGfxVisibility(class Gfx * gfx,bool f); 
  833. void    SetGfxVisibility(bool f, Set & s);
  834.  
  835. //
  836. //Search through theimage to find a Gfx object with this id
  837. // 
  838. Gfx * GetGfxWithId(int id);
  839.  
  840. //
  841. //Tell theimage to reset itself
  842. //
  843. void    ResetGfx();
  844.  
  845.  
  846.  
  847.  
  848.  
  849. //
  850. //Force update of image and propagation of position change
  851. //
  852. void    ForceSizeUpdate(){
  853.     SizeChanged();
  854.     MS_Moved();
  855.     Send(0,eNEventMoved,0);
  856.     PropagateEvent(eNEventMoved,eEventNull,this);    
  857. }
  858.  
  859.  
  860.  
  861. //
  862. //Some position  has changed so reset the image
  863. //
  864. bool    SizeChanged(){
  865. AdjustSize();
  866. ResetGfx();
  867. SendPositionChange();
  868. return TRUE;
  869. }
  870.  
  871. void    SignalSizeChange(Events notevent= eEventNull);
  872.  
  873. //
  874. //Check if our current position needs to be changed (e.g. because of a LC)
  875. //
  876. virtual bool AdjustSize();
  877.  
  878.  
  879. //
  880. //There has been a change in the dependencies of an incident relation
  881. //
  882. void    DepChange(Events ,DepTypes);
  883.  
  884. //
  885. //Are we visible
  886. //
  887. void    ResetVisibility();
  888. virtual bool GetVisibilityDep(); 
  889. bool    GetVisible() {return TestVGEFlag(eVGEVisible);}
  890. void    SetVisible(bool s); 
  891.  
  892.  
  893.  
  894. //
  895. //This element may draw other connected elements.
  896. //This is determined by the event dependenies in the incident
  897. //relations. For performance reasons we keep track of whether
  898. //this element draws other elements
  899. // 
  900. bool    DrawOthers(){return TestVGEFlag(eVGEDrawOthers);}
  901. void    DrawOthers(bool b){SetVGEFlag(eVGEDrawOthers,b);}
  902.  
  903. //
  904. //Draw this element
  905. //    
  906.  
  907. virtual void Draw(Rectangle r,void * v);
  908.  
  909. //
  910. //Draw connected elements
  911. //
  912. void    DrawAll(Rectangle r,void * v);
  913.  
  914. //
  915. //A hook for drawing
  916. //
  917. virtual bool MS_Draw(Rectangle,void *){return TRUE;}
  918.  
  919.  
  920.  
  921. //
  922. //Access to the views list
  923. //
  924. void    AddView(Object*);
  925. void    RemoveView(Object*);
  926.  
  927. //
  928. //Return the point that is defined by lp, (e.g. cNW,cCenter, etc.)
  929. //
  930. virtual bool  GetLocPt(LocPt p, Point *p ,void * data = 0);
  931.  
  932. //
  933. //Find the element that the relation rel should connect to.
  934. //If this element is  not visible then find a connected relation
  935. //that has the eEndPtReference event set
  936. // 
  937. VGraphElement*    GetEndPointElt(VRelation * rel = 0, int maxhops = gMaxEndPtHops);
  938.  
  939.  
  940.  
  941.  
  942.  
  943.  
  944.  
  945. void        SignalImageChange(Rectangle r,bool myChange = TRUE);
  946. void        GfxIBBoxChanged(Rectangle r);
  947. Rectangle    GetReferenceIBBox();
  948.  
  949. virtual    void MakeImages();
  950. virtual    void MS_MakeImages(){}
  951.  
  952.  
  953. //
  954. //Call all of the vgraphelements connected to the sgelt of this element
  955. //
  956. void AllScale(float , float );
  957. void AllScale(float );
  958. void AllRotateByRadian(double theta = 0.0);
  959. void AllRotateByDegree(double degree = 0.0);
  960. void AllRotateTo(Point p);
  961. void AllSetOrigin(Point p, bool notify = TRUE);
  962. void AllSetExtent(Point p, bool notify = TRUE);
  963. void AllSetP1(Point p);
  964. void AllSetP2(Point p);
  965. void AllMoveTo(Point);
  966. void AllReshape(Point, LocPt, bool b=FALSE);
  967. void AllReshapeBy(Point, LocPt, bool b=FALSE);
  968. void AllMoveBy(Point p );
  969. void AllSetVisible(bool s); 
  970. void AllSetGfxVisibility(int id,bool state, bool prop = FALSE,bool protosToo = FALSE);
  971. void AllRemoveView(Object*);
  972. void AllSetFlag(VGEFlags flag, bool f);
  973. void AllSetVGEFlag(VGEFlags flag, bool f);
  974.  
  975.  
  976.  
  977. OStream& PrintOn(OStream&);
  978. IStream& ReadFrom(IStream&);
  979.  
  980.  
  981. };
  982.  
  983.  
  984. void    ShuffleElts(VGraphElement * vgraph, Rectangle r, int dir,ElementOkFunc =0);
  985. void    ShoveElts(VGraphElement * vgraph, Rectangle r,ElementOkFunc func =0);
  986. void    SuckElts(VGraphElement * vgraph, Rectangle r,ElementOkFunc func =0);
  987.  
  988.  
  989. #endif  VGraphElement_h
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.  
  997.  
  998.  
  999.  
  1000.  
  1001.